home *** CD-ROM | disk | FTP | other *** search
/ Deutsche Edition 1 / Deutsche Edition 1.iso / amok / amok_lha / amok59.lha / AmokEd_V1.02b / txt / EdCmd1.mod < prev    next >
Text File  |  1993-08-15  |  17KB  |  572 lines
  1. (*************************************************************************
  2.  
  3. :Program.    EdCmd1.mod
  4. :Contents.   Commands for AmokEd
  5. :Author.     Hartmut Goebel
  6. :Language.   Oberon
  7. :Translator. Amiga Oberon Compiler V1.17.1
  8. :Imports.    SupLib (Hartmut Goebel)
  9. :History.    V0.2, 29 Dec 1990 Hartmut Goebel [hG]
  10. :History.    V1.0, 14 Apr 1991 [hG]
  11. :History.    V1.0b 26 Apr 1991 [hG] -Bug in Quit
  12. :History.    V1.0c 12 Aug 1991 [hG] changed Quit-mechanism
  13. :Date.       14 Aug 1991 14:37:30
  14.  
  15. *************************************************************************)
  16.  
  17. MODULE EdCmd1;
  18. (* $Debug- *)
  19. IMPORT
  20.   e: Exec,
  21.   d: Dos,
  22.   edD: EdDisplay,
  23.   edE: EdErrors,
  24.   edG: EdGlobalVars,
  25.   edK: EdKeyboard,
  26.   edL: EdLowLevel,
  27.   edM: EdMovement,
  28.   eMn: EdMenu,
  29.   g: Graphics,
  30.   I: Intuition,
  31.   ol: OberonLib,
  32.   sl: SupLib,
  33.   str: Strings,
  34.   sys: SYSTEM;
  35.  
  36. CONST
  37.   (* Flags für einzelne Kommandos *)
  38.   escImm* = 0; (* unterscheiden ESCIMM - ESC *)
  39.   resetToggle* = 0;
  40.   setToggle* = 1;
  41.   ifElse* = 0;
  42.   while* = 1;
  43.   rxQuit* = 0; (* beendet auf jeden Fall *)
  44.  
  45.   (* Relationen *)
  46.   relLess = 1;
  47.   relGreater = 2;
  48.   relEqual = 4;
  49.  
  50.   BadConditional = "Bad conditional";
  51.   FileHasBeenModified = "*** File has been modified ***";
  52.   CantUniconify = "Can't UnIconify";
  53.  
  54. VAR
  55.   SaveTopLine: LONGINT;
  56.   SavePos, SaveTopPos: INTEGER;
  57.  
  58. (* ---------- esc, escimm --------- *)
  59.  
  60. PROCEDURE EscapeCommLineMode*;
  61. BEGIN
  62.   IF edG.commLineMode IN edG.Status THEN
  63.     IF edG.LineBufferLen > 0 THEN
  64.       DISPOSE(edG.recallBuffer);
  65.       edG.recallBuffer := edL.CopyString(sys.ADR(edG.LineBuffer));
  66.     END;
  67.     EXCL(edG.Status,edG.commLineMode);
  68.     edK.ReturnOveride(FALSE);
  69.     edG.Text.topLine := SaveTopLine; edG.Text.pos := SavePos;
  70.     edG.Text.topPos := SaveTopPos; edD.TextLoad;
  71.     g.SetAPen(edG.RPort,0);
  72.     g.RectFill(edG.RPort,edD.Col(0),edD.Row(edG.Rows-1)-1,
  73.                edG.XBase+edG.XPixs,edG.YBase+edG.YPixs);
  74.     edD.TextDisplaySeg(edG.Rows-2,2);
  75.   END;
  76. END EscapeCommLineMode;
  77.  
  78.  
  79. PROCEDURE doEsc*;
  80. BEGIN
  81.   IF edG.commLineMode IN edG.Status THEN
  82.     EscapeCommLineMode;
  83.     RETURN;
  84.   END;
  85.   edD.PutBackLine;
  86.   edL.WindowTitle;
  87.   IF (escImm IN edG.ArgSet) AND (edG.Arg[0] # NIL) THEN
  88.     edG.LineBufferLen := str.Length(edG.Arg[0]^);
  89.     e.CopyMem(edG.Arg[0]^,edG.LineBuffer,edG.LineBufferLen+1);
  90.   ELSE
  91.     edG.LineBuffer := ""; edG.LineBufferLen := 0;
  92.   END;
  93.   INCL(edG.Status,edG.commLineMode);
  94.   edK.ReturnOveride(TRUE);
  95.   SaveTopLine := edG.Text.topLine;
  96.   SavePos := edG.Text.pos; SaveTopPos := edG.Text.topPos;
  97.   edG.Text.topLine := edG.Text.line-edG.Rows+1;
  98.   edG.Text.pos := edG.LineBufferLen; edG.Text.topPos := 0;
  99.   g.SetAPen(edG.RPort,0);
  100.   g.RectFill(edG.RPort,edD.Col(0),edD.Row(edG.Rows-1),
  101.              edG.XBase+edG.XPixs,edG.YBase+edG.YPixs);
  102.   g.SetAPen(edG.RPort,1);
  103.   g.Move(edG.RPort,edD.Col(0),edD.Row(edG.Rows-1)-1);
  104.   g.Draw(edG.RPort,edG.XBase+edG.XPixs,edD.Row(edG.Rows-1)-1);
  105.   edD.TextDisplaySeg(edG.Rows-1,1);
  106. END doEsc;
  107.  
  108.  
  109. PROCEDURE doRecall*;
  110. BEGIN
  111.   INCL(edG.ArgSet,escImm);
  112.   edG.Arg[0] := edG.recallBuffer;
  113.   doEsc;
  114. END doRecall;
  115.  
  116.  
  117. PROCEDURE doReturn*;
  118. VAR
  119.   Buffer: edG.StringPtr;
  120. BEGIN
  121.   IF edG.commLineMode IN edG.Status THEN
  122.     Buffer := edL.CopyString(sys.ADR(edG.LineBuffer));
  123.     EscapeCommLineMode;
  124.     IF Buffer # NIL THEN
  125.       edG.ExecCmd(Buffer);
  126.       DISPOSE(Buffer);
  127.     END;
  128.   ELSE
  129.     edG.Text.pos := 0;
  130.     edM.doDownAdd;
  131.   END;
  132. END doReturn;
  133.  
  134. (*-----------------------------------------------------------------------*)
  135. (*
  136.  * repeat X command
  137.  *
  138.  * (if X is not a number it can be abbr. with 2 chars)
  139.  *
  140.  * X =  N     -number of repeats
  141.  *      line  -current line # (lines begin at 1)
  142.  *      lbot  -#lines to the bottom, inc. current
  143.  *      cleft -column # (columns begin at 0)
  144.  *              (thus is also chars to the left)
  145.  *      cright-#chars to eol, including current char
  146.  *      tr    -#char positions to get to next tab stop
  147.  *      tl    -#char positions to get to next backtab stop
  148.  *)
  149.  
  150. PROCEDURE doRepeat*;
  151. VAR
  152.   n: LONGINT;
  153.   Buffer, aux: edG.StringPtr;
  154.   len: INTEGER;
  155. BEGIN
  156.   edL.BreakReset;
  157.   IF edL.StrToInt(edG.Arg[0],n) THEN
  158.     IF n = -1 THEN n := MAX(LONGINT); END;
  159.   ELSE
  160.     CASE CAP(edG.Arg[0][0]) OF
  161.      "L": CASE CAP(edG.Arg[0][1]) OF
  162.            "I": n := edG.Text.line+1;
  163.           |"B": n := edG.Text.numberOfLines-edG.Text.line;
  164.           ELSE n := -1; END;
  165.     |"C": CASE CAP(edG.Arg[0][1]) OF
  166.            "L": n := edG.Text.pos;
  167.           |"R": n := edG.LineBufferLen - edG.Text.pos;
  168.           ELSE n := -1; END;
  169.     |"T": CASE CAP(edG.Arg[0][1]) OF
  170.            "R": n := edG.Text.tabStop-(edG.Text.pos MOD edG.Text.tabStop);
  171.           |"L": n := edG.Text.pos MOD edG.Text.tabStop;
  172.                 IF n = 0 THEN n := edG.Text.tabStop; END;
  173.           ELSE n := -1; END;
  174.     ELSE n := -1; END;
  175.   END;
  176.   IF n < 0 THEN
  177.     edG.Rc := edE.cmdError; edL.Title(BadConditional); RETURN;
  178.   END;
  179.   Buffer := edL.CopyString(edG.Arg[1]); IF Buffer = NIL THEN RETURN END;
  180.   len := str.Length(Buffer^);
  181.   aux := edG.Arg[1];
  182.   LOOP
  183.     edG.ExecCmd(Buffer);
  184.     IF (edG.Rc >= edE.AbortLevel) THEN EXIT END;
  185.     IF edL.BreakCheck() THEN edG.Rc := edE.AbortLevel; EXIT END;
  186.     DEC(n);
  187.     IF n = 0 THEN EXIT; END;
  188.     e.CopyMem(aux^,Buffer^,len);
  189.   END;
  190.   DISPOSE(Buffer);
  191. END doRepeat;
  192.  
  193. (*-----------------------------------------------------------------------*)
  194.  
  195. PROCEDURE Xor(a{0},b{1}: BOOLEAN): BOOLEAN;
  196. BEGIN
  197.   RETURN (a AND ~b) OR (~a AND b);
  198. END Xor;
  199.  
  200. (*
  201.  * IF condition trueaction, IFELSE condition trueaction falseaction
  202.  *
  203.  *  condition:  !condition NOT the specified condition.
  204.  *  #          toggle number is SET
  205.  *  top        top of file (on first line)
  206.  *  bot        end of file (on last line)
  207.  *  left       start of line (leftmost column)
  208.  *  right      end of line (nothing but spaces under and to the right)
  209.  *  modified   text has been modified
  210.  *  insert     currently in insert mode
  211.  *  y[<=>]#    cursor is (any OR combo of <,>,=) row # (line numbers start at 1)
  212.  *  x[<=>]#    cursor is (<,>,<=,>=,<>) column #       (columns start at 1)
  213.  *              <> means 'not equal'
  214.  *
  215.  *  cl         char under cursor is lower case
  216.  *  cu         char under cursor is upper case
  217.  *  ca         char under cursor is alpha
  218.  *  cn         char under cursor is numeric
  219.  *  cb         char within selected block
  220.  *  c[<=>]#    char under cursor is (combo of <,>,and =) #
  221.  *)
  222.  
  223. PROCEDURE TestCondition(condStr: edG.StringPtr): BOOLEAN;
  224. VAR
  225.   not:BOOLEAN;
  226.   relation: INTEGER;
  227.   value: LONGINT;
  228.  
  229.   PROCEDURE GetRelation():BOOLEAN;
  230.   VAR
  231.     i: INTEGER;
  232.     help: ARRAY 4 OF CHAR;
  233.   BEGIN
  234.     (* $RangeChk- *)
  235.     WHILE (condStr[0] > "A") DO (* Anfang der relation suchen *)
  236.       INC(condStr);
  237.     END;
  238.     i := 0;
  239.     WHILE (condStr[i] >= "<") AND (condStr[i] <= ">") DO
  240.       INC(i);
  241.     END;
  242.     (* $RangeChk= *)
  243.     IF i>3 THEN
  244.       RETURN FALSE; END;
  245.     e.CopyMem(condStr^,help,i);
  246.     INC(condStr,i);
  247.     relation := 0;
  248.     REPEAT
  249.       DEC(i);
  250.       CASE  help[i] OF
  251.        "<": INC(relation,relLess);
  252.       |"=": INC(relation,relEqual);
  253.       |">": INC(relation,relGreater);
  254.       ELSE
  255.         RETURN FALSE;
  256.       END;
  257.     UNTIL i=0;
  258.     IF (relation = 0) OR (relation >= 7) THEN (* zuviel Bedingungen *)
  259.       RETURN FALSE; END;
  260.     IF relation = relGreater+relLess THEN  (* ungleich *)
  261.       not := ~not; relation := relEqual; END;
  262.     RETURN TRUE;
  263.   END GetRelation;
  264.  
  265.   PROCEDURE TestRelationTo(rel{0}: INTEGER;value{1},val{2}:LONGINT): BOOLEAN;
  266.   BEGIN
  267.     CASE rel OF
  268.       relLess: RETURN (val < value);
  269.     | relGreater: RETURN (val > value);
  270.     | relEqual: RETURN (val = value);
  271.     | relLess+relEqual: RETURN (val <= value);
  272.     | relGreater+relEqual: RETURN (val >= value);
  273.     ELSE
  274.     END;
  275.   END TestRelationTo;
  276.  
  277. BEGIN
  278.   IF condStr[0] = "!" THEN not := TRUE; INC(condStr);
  279.                       ELSE not := FALSE; END;
  280.   CASE condStr[0] OF
  281.   "T": RETURN Xor(not,(edG.Text.line = 0)); |
  282.   "B": RETURN Xor(not,(edG.Text.actLinePtr = edG.Text.lineList.tail)); |
  283.   "L": RETURN Xor(not,(edG.Text.pos = 0)); |
  284.   "R": RETURN Xor(not,(edG.Text.pos=edG.LineBufferLen)); |
  285.   "M": RETURN Xor(not,edG.modified IN edG.Text.status); |
  286.   "I": INC(condStr);
  287.        CASE condStr[0] OF
  288.        "0".."9":
  289.          IF edL.StrToInt(condStr,value) AND (value<edG.MaxInternToggle) THEN
  290.            RETURN Xor(not,SHORT(value) IN edG.Text.toggles); END;
  291.        ELSE
  292.          RETURN Xor(not,edG.insertMode IN edG.Text.status);
  293.        END; |
  294.   "C": INC(condStr);
  295.        CASE condStr[0] OF
  296.        "L": RETURN Xor(not,(edG.LineBuffer[edG.Text.pos] >= "a")
  297.                        AND (edG.LineBuffer[edG.Text.pos] <= "z")); |
  298.        "U": RETURN Xor(not,(edG.LineBuffer[edG.Text.pos] >= "A")
  299.                        AND (edG.LineBuffer[edG.Text.pos] <= "Z")); |
  300.        "A": RETURN Xor(not,edL.IsAscii(edG.LineBuffer[edG.Text.pos])); |
  301.        "N": RETURN Xor(not,(edG.LineBuffer[edG.Text.pos] >= "0")
  302.                        AND (edG.LineBuffer[edG.Text.pos] <= "9")); |
  303.        "B": RETURN (Xor(not,(edG.Text = edG.Block.Owner) AND
  304.                        (edG.Text.line >= edG.Block.SNum) AND
  305.                        (edG.Text.line <= edG.Block.ENum))); |
  306.        ELSE
  307.          IF GetRelation() AND edL.StrToInt(condStr,value) THEN
  308.            RETURN Xor(not,TestRelationTo(relation,value,
  309.                       ORD(edG.LineBuffer[edG.Text.pos]))); END;
  310.        END; |
  311.   "X": IF GetRelation() AND edL.StrToInt(condStr,value) THEN
  312.          RETURN Xor(not,TestRelationTo(relation,value,edG.Text.pos+1)); END;|
  313.   "Y": IF GetRelation() AND edL.StrToInt(condStr,value) THEN
  314.          RETURN Xor(not,TestRelationTo(relation,value,edG.Text.line+1)); END;|
  315.   ELSE
  316.     IF edL.StrToInt(condStr,value) AND (value < edG.MaxToggle) THEN
  317.       value := ol.ModDiv(value,16); (* SIZE(SET) in Bits *);
  318.       relation := SHORT(sys.REG(1)); (* value MOD 16 steht in D1 *)
  319.       RETURN  Xor(not,relation IN edG.Toggles[value]);
  320.     END;
  321.   END; (* CASE condStr[0] *)
  322.   edG.Rc := edE.cmdError;
  323.   edL.Title(BadConditional);
  324.   RETURN FALSE;
  325. END TestCondition;
  326.  
  327.  
  328. PROCEDURE doIf*;
  329. VAR
  330.   Buffer, Condition, aux: edG.StringPtr;
  331.   len: INTEGER;
  332.   While: BOOLEAN; (* wg. edG.ExecCmd() *)
  333. BEGIN
  334.   While := while IN edG.ArgSet;
  335.   IF While THEN
  336.     Buffer := edL.CopyString(edG.Arg[1]); IF Buffer = NIL THEN RETURN END;
  337.     len := str.Length(Buffer^);
  338.     aux := edG.Arg[1];
  339.   ELSE
  340.     Buffer := edG.Arg[1]; (* nicht erst kopieren *)
  341.   END;
  342.   Condition := edG.Arg[0]; str.Upper(Condition^); (* sichern *)
  343.   edL.BreakReset;
  344.   LOOP
  345.     IF TestCondition(Condition) THEN
  346.       IF (edG.Rc >= edE.AbortLevel) THEN EXIT END;
  347.       IF edL.BreakCheck() THEN edG.Rc := edE.AbortLevel; EXIT END;
  348.       edG.ExecCmd(Buffer);
  349.       IF NOT While THEN EXIT; END;
  350.     ELSIF (ifElse IN edG.ArgSet) AND NOT While THEN
  351.       edG.ExecCmd(edG.Arg[2]);
  352.       EXIT;
  353.     ELSE
  354.       EXIT;
  355.     END;
  356.     e.CopyMem(aux^,Buffer^,len);
  357.   END;
  358.   IF While THEN DISPOSE(Buffer); END;
  359. END doIf;
  360.  
  361. (*----------------------------------------------------------------------*)
  362.  
  363. PROCEDURE doIconify*;
  364. VAR
  365.   win: I.WindowPtr;
  366.   nw: I.NewWindow;
  367. BEGIN
  368.   IF NOT (edG.iconMode IN edG.Text.status) THEN
  369.     edD.PutBackLine;
  370.     win := edG.Text.window;
  371.     nw := edG.StdWindow;
  372.     edG.Text.leftEdge := win.leftEdge;
  373.     edG.Text.topEdge := win.topEdge;
  374.     edG.Text.width := win.width;
  375.     edG.Text.height := win.height;
  376.     nw.height := 11;
  377.     nw.width  := 20 + 2*8 + str.Length(edG.Text.name)*8;
  378.     nw.leftEdge:= edG.Text.iconLeft;
  379.     nw.topEdge := edG.Text.iconTop;
  380.     nw.blockPen := -1;
  381.     IF edG.modified IN edG.Text.status THEN
  382.       nw.blockPen := 3;
  383.       (* IF edG.kick20 IN edG.Status THEN END; *)
  384.     END;
  385.     nw.flags := nw.flags-LONGSET{I.windowSizing,I.windowDepth,I.activate};
  386.     IF I.windowActive IN win.flags THEN (* wegen ARexx *)
  387.       INCL(nw.flags,I.activate); END;
  388.     nw.firstGadget := NIL;
  389.     nw.title := sys.ADR(edG.Text.name);
  390.     IF edG.Screen # NIL THEN
  391.       nw.screen := edG.Screen;
  392.       nw.type := I.customScreen;
  393.     END;
  394.     e.Forbid;  (* make sure, there is memory *)
  395.     sl.CloseWindowSafely(win);
  396.     win := sl.OpenPortWindow(nw,edG.MainPort);
  397.     e.Permit;
  398.     edG.Text.window := win;
  399.     edD.SetWindowParams;
  400.  
  401.     INCL(edG.Text.status,edG.iconMode);
  402.     INCL(edG.Status,edG.dontReplyIntuiMsg);
  403.   END;
  404. END doIconify;
  405.  
  406.  
  407. PROCEDURE unIconify*;
  408. VAR
  409.   win,win2: I.WindowPtr;
  410.   nw: I.NewWindow;
  411. BEGIN
  412.   IF edG.iconMode IN edG.Text.status THEN
  413.     win := edG.Text.window;
  414.     nw := edG.StdWindow;
  415.     edG.Text.iconLeft := win.leftEdge; edG.Text.iconTop := win.topEdge;
  416.     nw.leftEdge := edG.Text.leftEdge; nw.width  := edG.Text.width;
  417.     nw.topEdge  := edG.Text.topEdge;  nw.height := edG.Text.height;
  418.     nw.blockPen := -1;
  419.     nw.title    := sys.ADR(edG.Text.name);
  420.     nw.firstGadget := sys.ADR(edG.Text.propGadget);
  421.     IF edG.Screen # NIL THEN
  422.       nw.screen := edG.Screen;
  423.       nw.type := I.customScreen;
  424.     END;
  425.     win2 := sl.OpenPortWindow(nw,win.userPort);
  426.     IF win2 # NIL THEN
  427.       sl.CloseWindowSafely(win);
  428.       edG.Text.window := win2;
  429.       eMn.MenuStrip(win2);
  430.       edG.RPort := win2.rPort;
  431.       IF edG.Text.font # NIL THEN g.SetFont(edG.RPort,edG.Text.font); END;
  432.       edD.SetWindowParams;
  433.       edD.TextLoad;
  434.       edD.TextRedisplay;
  435.       edL.WindowTitle;
  436.       EXCL(edG.Text.status,edG.iconMode);
  437.       INCL(edG.Status,edG.dontReplyIntuiMsg);
  438.     ELSE
  439.       edL.Title(CantUniconify);
  440.       edG.Rc := edE.cmdSevere;
  441.     END;
  442.   END;
  443. END unIconify;
  444.  
  445. (*-----------------------------------------------------------------------*)
  446. (* $Debug= *)
  447. PROCEDURE HandleQuitFlags*;
  448. BEGIN
  449.   IF NOT (edG.macroWithQuit IN edG.Text.status) THEN
  450.     EXCL(edG.Text.status,edG.quit);
  451.   END;
  452.   EXCL(edG.Text.status,edG.macroWithQuit);
  453. END HandleQuitFlags;
  454.  
  455.  
  456. PROCEDURE doQuit*;
  457. BEGIN
  458.   edD.PutBackLine;
  459.   IF NOT (edG.modified IN edG.Text.status) OR (edG.quit IN edG.Text.status)
  460.   OR (rxQuit IN edG.ArgSet) THEN
  461.     edL.EndEdit;
  462.     INCL(edG.Status,edG.dontReplyIntuiMsg);
  463.     IF edG.Text=NIL THEN
  464.       INCL(edG.Status,edG.quitQuit);
  465.       RETURN;
  466.     END;
  467.     edD.TextLoad;
  468.     edD.SwitchEdit(edG.Text);
  469.   ELSE
  470.     edG.Text.status := edG.Text.status + LONGSET{edG.macroWithQuit,edG.quit};
  471.     IF edG.iconMode IN edG.Text.status THEN unIconify; END;
  472.     edG.Rc := edE.cmdFailed; edL.Title(FileHasBeenModified);
  473.   END;
  474. END doQuit;
  475. (* $Debug- *)
  476. (*-----------------------------------------------------------------------*)
  477.  
  478. PROCEDURE doMargin*;
  479. VAR
  480.   long: LONGINT;
  481. BEGIN
  482.   IF edL.StrToInt(edG.Arg[0],long) AND (long < 125) THEN
  483.     edG.Text.margin := ABS(SHORT(long));
  484.   ELSE
  485.     edL.Title(edG.ErrorMarginOver124); edG.Rc := edE.cmdError;
  486.   END;
  487. END doMargin;
  488.  
  489.  
  490. PROCEDURE doTabstop*;
  491. VAR
  492.   long: LONGINT;
  493. BEGIN
  494.   IF edL.StrToInt(edG.Arg[0],long) AND (long < edG.MaxLineLength) THEN
  495.     edG.Text.tabStop := ABS(SHORT(long));
  496.   ELSE
  497.     edL.Title(edG.BadArgument); edG.Rc := edE.cmdError;
  498.   END;
  499. END doTabstop;
  500.  
  501. (*-----------------------------------------------------------------------*)
  502.  
  503. PROCEDURE doToggle*;
  504. VAR
  505.   Toggle: POINTER TO LONGSET;
  506.   long,set: LONGINT;
  507.   Title: ARRAY 20 OF CHAR;
  508.   bit: INTEGER;
  509.   ok: BOOLEAN;
  510. BEGIN
  511.   edG.Rc := edE.cmdError;
  512.   str.Upper(edG.Arg[0]^);
  513.   ok := TRUE;
  514.   Toggle := sys.ADR(edG.Text.status);
  515.   IF edG.Arg[0]^ ="WORDWRAP" THEN
  516.     Title := "WordWrap"; bit := edG.wordWrap;
  517.   ELSIF edG.Arg[0]^ ="INSERTMODE" THEN
  518.     Title := "InsertMode"; bit := edG.insertMode;
  519.   ELSIF edG.Arg[0]^ ="SAVETABS" THEN
  520.     Title := "SaveTabs"; bit := edG.saveTabs;
  521.   ELSIF edG.Arg[0]^ ="IGNORECASE" THEN
  522.     Title := "IgnoreCase"; bit := edG.ignoreCase;
  523.   ELSIF edG.Arg[0]^ ="AUTOINDENT" THEN
  524.     Title := "AutoIndent"; bit := edG.autoIndent;
  525.   ELSIF edG.Arg[0]^ ="NUMLOCK" THEN
  526.     Title := "NumLock"; bit := edG.numLock;
  527.     Toggle := sys.ADR(edG.Status);
  528.   ELSIF edG.Arg[0][0] = "I" THEN
  529.     INC(edG.Arg[0]);
  530.     IF edL.StrToInt(edG.Arg[0],long) THEN
  531.       bit := SHORT(ABS(long));
  532.       IF bit < edG.MaxInternToggle THEN
  533.         Title := "Toggle i";
  534.         str.Append(Title,edG.Arg[0]^);
  535.         Toggle := sys.ADR(edG.Text.toggles);
  536.       ELSE
  537.         ok := FALSE;
  538.       END;
  539.     ELSE
  540.       ok := FALSE;
  541.     END;
  542.   ELSIF edL.StrToInt(edG.Arg[0],long) THEN
  543.     long := SHORT(ABS(long));
  544.     IF long < edG.MaxToggle THEN
  545.       set := ol.ModDiv(ABS(long),32); (* SIZE(LONGSET) in Bits   *)
  546.       bit := SHORT(sys.REG(1));       (* long MOD 32 steht in D1 *)
  547.       Toggle := sys.ADR(edG.Toggles[SHORT(set)]);
  548.       Title := "Toggle ";
  549.       str.Append(Title,edG.Arg[0]^);
  550.     ELSE
  551.       ok := FALSE;
  552.     END;
  553.   ELSE
  554.     ok := FALSE;
  555.   END;
  556.   IF NOT ok THEN
  557.     edL.Title(edG.BadArgument); edG.Rc := edE.cmdError;
  558.   ELSE
  559.     IF  resetToggle IN edG.ArgSet THEN EXCL(Toggle^,bit);
  560.     ELSIF setToggle IN edG.ArgSet THEN INCL(Toggle^,bit);
  561.     ELSE Toggle^ := Toggle^ / LONGSET{bit};
  562.     END;
  563.     IF bit IN Toggle^ THEN str.Append(Title," ON");
  564.     ELSE str.Append(Title," OFF");
  565.     END;
  566.     edL.Title(Title); edG.Rc := edE.cmdValid2; (* Titel nicht ändern *)
  567.   END;
  568. END doToggle;
  569.  
  570. END EdCmd1.
  571.  
  572.